The management of events is a field of major importance in computing science. An event engine and system are used when some asynchronous external activity needs to be handled by a program or an application. For example, if a program needs to react when the user presses a mouse, an event “mouse pressed” can be created. Also, when a machine sends a message/event to the computer through a network, it can be processed as an event by the computer. In typical event engines, an event is fired when it occurs in a system. Once the event has been fired, handler functions can be implemented for listening to the event, and adapt the behavior of the program according to the event.
An event can contain parameters that are linked to the event type. For example, a mouse event may embed x,y parameters that represent the position on the screen where the user has clicked on the mouse. These parameters can be retrieved by the handler function, in order to further adapt the behavior of the program. For example, the position where the user clicked on the mouse can be used to find a button under the position, and trigger a click on this button.
The use of events is very common in programming languages such as C, C++, or Java. In common event engines, the events are fired by the system, and a developer can develop handler functions that derive from a generic handler function. This method allows a great flexibility for managing events, because any behavior can be defined in the handler function. In this case events are usually relatively low level events that depend directly on the platform and execution language. Such events are the events directly detectable by a machine with the associated parameters. Such events may be for example:                A “finger press” event associated with x,y coordinates when the finger of a user presses the screen of a touch device at the x,y position;        A “finger released” event associated with x,y coordinates when the finger of a user releases its finger from the screen of a touch device at the x,y position;        A “click” event associated with x,y coordinates when a user clicks on the mouse when the pointer is in the position at the x,y coordinates;        An “orientation” event, associated with an angle around an axis when the gyro of a device detects an orientation around this axis;        More generally, device sensor events such as GPS event with a geo position, accelerator events, etc. . . .        A “time tick” event, associated with a time, at ticks of a clock;        Etc. . . .These events are usually defined for one environment. For example a “Finger press” event may exist in Java for being executed by a Java Virtual Machine, a “Finger press” event exists natively for programming iPads, Windows Phones, etc. . . . The events on each environment of execution have their own definition: a “Finger press” event will have a different name, if not different parameters, when programming in each execution environment.        
Thus, such event handling methods are very hard, if not impossible, to use by non-developers. Indeed a man without skills in development and computing science engineering will hardly understand the meaning of a low-level or native event in each execution environment and be able to develop the associated handler functions.
Meanwhile, the designer of an interactive application will usually be interested in higher-level events. For example, the designer of an interactive application is interested in handling high-level event directly understandable as a natural behavior by the user of the interactive application. For example, the designer may be interested in handling events such as “double-tap” when a user taps rapidly twice a same area of a tactile surface. For handling such events using a traditional approach, one must detect successive events such as “finger pressed” and “finger released”, detect that these events occurred in a same area and close in time. This requires complex programming skills which are not always accessible to designers focused on building functional interactive applications.
The present application aims at making the design of interactive applications easier, notably by allowing a designer without skills in software development to manipulate a wider variety of events easily understandable at the designer level.